#ifndef __M_UTIL_H__
#define __M_UTIL_H__
#include "logger.hpp"
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <memory>
#include <vector>
#include <cstdint>
#include <jsoncpp/json/json.h>
#include <mysql/mysql.h>
#include<unordered_map>
#include<mutex>

#include <websocketpp/server.hpp>
//WebSocket++ 的核心服务端实现，提供了 WebSocket 服务端的基本功能（如连接管理、消息处理等）。
#include <websocketpp/config/asio_no_tls.hpp>
//指定使用 Asio 作为网络底层库（Boost.Asio 或 Standalone Asio），并禁用 TLS/SSL 加密（no_tls 表示不启用 HTTPS/WSS）。
typedef websocketpp::server<websocketpp::config::asio> wsserver_t;
//这是 WebSocket++ 的模板类，它表示一个基于 Asio 的非加密 WebSocket 服务端实例，重命名为wsserver_t





//这是一个工具类文件，包含工程中其他文件所需要的头文件和函数
//为了让外界使用成员函数时不用实例化对象，因此将成员函数都设置为静态







//mysql_util：数据库的连接&初始化，句柄的销毁，语句的执行
//初始化过程：
//1.初始化mysql操作句柄
//2.连接mysql服务器
//3.设置客户端的字符集
//4.选择想要操作的数据库(只有一个就不实现了)
//语句的执行（不包含查询，查询需要将结果保存到本地，获取结果条数，遍历结果集）
//句柄的销毁

class mysql_util{
    public:
        //初始化过程：
        static MYSQL *mysql_create(const std::string &host,
            const std::string &username,
            const std::string &password,
            const std::string &dbname,
            uint16_t port = 3306){
                //1.初始化mysql操作句柄
                MYSQL *mysql = mysql_init(NULL);
                if(mysql == NULL){
                    ELOG("mysql init failed!");
                    return NULL;
                }
                //2.连接mysql服务器
                if(mysql_real_connect(mysql,
                    host.c_str(),
                    username.c_str(),
                    password.c_str(),
                    dbname.c_str(),port,NULL,0) == NULL){
                    ELOG("connect mysql server failed : %s",mysql_error(mysql));
                    //如果连接失败直接就把mysql句柄销毁了
                    mysql_close(mysql);
                    return NULL;
                }
                //3.设置客户端的字符集
                if(mysql_set_character_set(mysql,"utf8")!= 0){
                    ELOG("set client character failed : %s",mysql_error(mysql));
                    return NULL;
                }
                return mysql;
            }

        //语句的执行（不包含查询，查询需要将结果保存到本地，获取结果条数，遍历结果集）
        static bool mysql_exec(MYSQL *mysql,const std::string &sql){
            int ret = mysql_query(mysql,sql.c_str());
            if(ret != 0){
                ELOG("%s\n",sql.c_str());
                ELOG("mysql query failed : %s\n",mysql_error(mysql));
                return false;
            }
            return true;
        }

        //句柄的销毁
        static void mysql_destroy(MYSQL *mysql){
            if(mysql != NULL){
                mysql_close(mysql);
            }
            return ;
        }



};


//json_util：封装实现json的序列化和反序列化
//序列化过程：
//1. 将需要进行序列化的数据，存储在Json::Value 对象中
//2. 实例化一个StreamWriterBuilder工厂类对象
//3. 通过StreamWriterBuilder工厂类对象生产一个StreamWriter对象
//4. 使用StreamWriter对象，对Json::Value中存储的数据进行序列化
//反序列化过程：
//1. 实例化一个CharReaderBuilder工厂类对象
//2. 使用CharReaderBuilder工厂类生产一个CharReader对象
//3. 定义一个Json::Value对象存储解析后的数据
//4. 使用CharReader对象进行json格式字符串str的反序列化
// parse(char *start,  char *end,  Json::Value *val,  string *err);
//5. 逐个元素去访问Json::Value中的数据
class json_util{
    public:
        //序列化过程：
        static bool serialize(const Json::Value &root,std::string &str){
            //1. 实例化一个StreamWriterBuilder工厂类对象
            Json::StreamWriterBuilder swb;
            //2. 通过StreamWriterBuilder工厂类对象生产一个StreamWriter对象(通过智能指针进行维护)
            std::unique_ptr<Json::StreamWriter>sw(swb.newStreamWriter());
            std::stringstream ss;//用于在内存中对字符串进行流式操作的类
            //3. 使用StreamWriter对象，对Json::Value中存储的数据进行序列化
            int ret = sw->write(root,&ss);
            if(ret != 0){
                ELOG("json serialize failed!!");
                return false;
            }
            str = ss.str();
            return true;
        }
        //反序列化过程：
        static bool unserialize(const std::string &str,Json::Value &root){
            //1. 实例化一个CharReaderBuilder工厂类对象
            Json::CharReaderBuilder crb;
            //2. 使用CharReaderBuilder工厂类生产一个CharReader对象
            std::unique_ptr<Json::CharReader> cr(crb.newCharReader());
            std::string err;
            //3. 使用CharReader对象进行json格式字符串str的反序列化
            bool ret = cr->parse(str.c_str(),str.c_str() + str.size(),&root,&err);
            // parse(char *start,  char *end,  Json::Value *val,  string *err);
            if(ret == false){
                ELOG("json unserialize failed: %s",err.c_str());
                return false;
            }
            return true;
        }
};


//string_util：主要是封装实现字符串的分割功能
class string_util{
    public:
        static int split(const std::string &src,const std::string &sep,std::vector<std::string>&res){
            size_t pos,idx = 0;
            while(idx < src.size()){
                pos = src.find(sep,idx);
                if(pos == std::string::npos){
                    //在字符串中没有找到间隔字符，跳出循环
                    res.push_back(src.substr(idx));
                    break;
                }
                if(pos == idx){//防止有连续间隔字符出现
                    idx += sep.size();
                    continue;
                }
                res.push_back(src.substr(idx,pos-idx));
                idx = pos + sep.size();
            }
            return res.size();
        }
};

//file_util：主要封装了文件数据的读取功能（对于html文件数据进行读取）

class file_util {
public:
    /**
     * @brief 读取文件内容到字符串
     * @param filename 要读取的文件路径
     * @param body 用于存储文件内容的字符串引用
     */
    static bool read(const std::string &filename, std::string &body) {
        // 以二进制模式打开文件
        // std::ios::binary 表示以二进制方式打开，避免文本模式下的字符转换
        std::ifstream ifs(filename, std::ios::binary);
        
        // 检查文件是否成功打开
        if (ifs.is_open() == false) {
            // 使用错误日志记录文件打开失败
            // ELOG可能是项目中自定义的日志宏
            // filename.c_str() 将C++字符串转换为C风格字符串
            ELOG("%s file open failed!!", filename.c_str());
            return false;
        }

        // 获取文件大小
        size_t fsize = 0;
        
        // 将文件指针移动到文件末尾
        ifs.seekg(0, std::ios::end);
        
        // 获取当前指针位置（即文件大小）
        fsize = ifs.tellg();
        
        // 将文件指针移回文件开头
        ifs.seekg(0, std::ios::beg);
        
        // 调整body字符串的大小以容纳整个文件内容
        // resize()会分配足够的空间，但不初始化内容
        body.resize(fsize);

        // 读取文件全部内容到body字符串中
        // &body[0] 获取字符串底层字符数组的首地址
        // C++11及以上标准保证std::string内存是连续的
        ifs.read(&body[0], fsize);

        // 检查读取操作是否成功
        // good()检查流状态是否正常（无错误）
        if (ifs.good() == false) {
            // 记录读取失败日志
            ELOG("read %s file content failed!", filename.c_str());
            
            // 关闭文件流
            ifs.close();
            return false;
        }

        // 成功读取后关闭文件
        ifs.close();
        
        // 返回成功状态
        return true;
    }
};



#endif